home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / bbsutil / dlx70bbs.zip / DLX70SRC.ZIP / KBD.ASM < prev    next >
Assembly Source File  |  1994-01-19  |  16KB  |  573 lines
  1.     TITLE    KBD Interace to MS Pascal
  2. ;
  3. ; Keyboard: Special Concurrent I/O Package for DLX
  4. ; Non-busy wait I/O
  5. ; Programmed by Richard Gillmann
  6. ;
  7. ; DLX Bulletin Board System V7.0
  8. ;
  9. ; FREEWARE NOTICE
  10. ;
  11. ; DLX V7.0 is placed in the public domain by its author, Richard Gillmann.
  12. ; Anyone who wishes to may run the program, copy it, or modify it for
  13. ; any purpose, including commercial gain.
  14. ;
  15. ; This package assumes that the display is in 80 column alpha mode
  16. ; It also assumes DOS 2 or higher
  17. ;
  18. wrapcol    equ    79        ; hard wrap at this column
  19. in_len    equ    120        ; number of characters in incoming buffer
  20. f_len    equ    10        ; number of characters in function key buffer
  21. ctrl_c    equ    3        ; ascii control c
  22. bell    equ    7        ; ascii bell character
  23. bs    equ    8        ; ascii backspace character
  24. tab    equ    9        ; ascii tab character
  25. lf    equ    10        ; ascii linefeed character
  26. cr    equ    13        ; ascii carriage return character
  27. ctrl_o    equ    15        ; ascii control o
  28. ctrl_q    equ    17        ; ascii control q
  29. ctrl_s    equ    19        ; ascii control s
  30. del    equ    255        ; ascii del character
  31. nattr    equ    7        ; normal video attribute
  32. dos    equ    21h        ; dos function call
  33. true    equ    1        ; ms pascal true
  34. false    equ    0        ; ms pascal false
  35.     page
  36. pushem    macro
  37.     push    bp
  38.     mov    bp,sp
  39.     push    ds
  40.     endm
  41. popem    macro
  42.     pop    ds
  43.     pop    bp
  44.     endm
  45.     page
  46.     extrn    screen_ptr:word
  47.     extrn    row0:byte,col0:byte,lmc0:byte,wrap0:byte,bs_local:byte;
  48.     extrn    stifled:byte,cancelled:byte,skipped:byte
  49. data    segment    para public 'data'
  50. columns    db    80        ; columns/row
  51. ecco    dw    1        ; echo flag: -1=echoing +1=not echoing
  52. cr_count db    0        ; carriage return count
  53. soft_cr    db    0        ; was last carriage return a soft one?
  54. ; incoming buffer
  55. inbuf    db    in_len dup(?)    ; incoming buffer
  56. in_cnt    dw    0        ; count of characters in the buffer
  57. in_head    dw    inbuf        ; head buffer offset
  58. in_tail    dw    inbuf        ; tail buffer offset
  59. ; function key buffer
  60. fbuf    db    f_len dup(?)    ; function key buffer
  61. f_cnt    dw    0        ; count of characters in fkey buffer
  62. f_head    dw    fbuf        ; fkey head buffer offset
  63. f_tail    dw    fbuf        ; fkey tail buffer offset
  64. tabsiz    db    8        ; tab spacing
  65. data    ends
  66. dgroup    group    data
  67.     page
  68. code    segment    para public 'code'
  69.     assume  cs:code
  70.  
  71.     public    f_count        ; return count of function keys typed
  72.     public    f_recv        ; read function key
  73.     public    kr_count    ; return count of chars in incoming buffer
  74.     public    k_recv        ; read next char from incoming buffer
  75.     public    echo_kbd    ; re-enable echoing
  76.     public    installh    ; install our interrupt handler
  77.     public    restoreh    ; restore DOS interrupt handler
  78.     public    purgekbd    ; empty kbd buffer
  79.     public    kbd_soft    ; was last cr a soft one?
  80.  
  81. key_io    label    word        ; word equivalent of
  82. key_io2    dd    ?        ; address of normal key interrupt handler
  83.     page
  84. ;
  85. ; internal routine
  86. ; direct screen write
  87. ; write char in al to current row,col
  88. ;
  89.     assume    ds:dgroup
  90. dsw    proc    near
  91.     push    es        ; save extra segment
  92.     push    ax        ; save char
  93.     mov    ax,screen_ptr+2    ; segment of screen buffer
  94.     mov    es,ax        ; to extra segment
  95.     assume    es:nothing
  96.     mov    al,row0        ; row
  97.     mul    columns        ; * 80
  98.     add    al,col0        ; + column
  99.     adc    ah,0        ; (carry)
  100.     sal    ax,1        ; double to allow for attribute bytes
  101.     mov    bx,ax        ; copy result to index register
  102.     pop    ax        ; restore character
  103.     mov    es:[bx],al    ; direct write
  104.     pop    es        ; restore extra segment
  105.     assume    es:dgroup
  106.     ret            ; done
  107. dsw    endp
  108.     page
  109. ;
  110. ; internal routine
  111. ; advance cursor
  112. ; scrolling is the responsibility of higher levels
  113. ;
  114.     assume    ds:dgroup
  115. advance    proc    near
  116.     inc    col0        ; next column
  117.     cmp    col0,80        ; past last column?
  118.     jb    adv_x        ; jump if not
  119.     mov    col0,0        ; to column
  120.     inc    row0        ; next row
  121. adv_x:    ret            ; done
  122. advance    endp
  123.     page
  124. ;
  125. ; internal routine: display a character
  126. ; char in al, preserved by this call
  127. ;
  128.     assume    ds:dgroup
  129. display    proc    near
  130.     push    ax        ; save char
  131. ; branch if special char
  132.     cmp    bs_local,1    ; handle this ourselves?
  133.     jne    dis_0        ; jump if not
  134.     cmp    al,bs        ; backspace?
  135.     je    dis_1        ; jump if so
  136.     cmp    al,del        ; del?
  137.     je    dis_1        ; jump if so
  138. dis_0:    cmp    al,cr        ; carriage return?
  139.     je    dis_2        ; jump if so
  140.     cmp    al,bell        ; bell?
  141.     je    dis_4        ; jump if so
  142.     cmp    al,' '        ; printable character?
  143.     jb    dis_x        ; jump if not
  144. ; normal char
  145.     call    dsw        ; direct screen write
  146.     call    advance        ; advance the cursor
  147.     jmp    short dis_x    ; finish
  148. ; backspace or del
  149. dis_1:    mov    dl,lmc0        ; left margin column
  150.     cmp    col0,dl        ; already at left margin?
  151.     jbe    dis_x        ; jump if so
  152.     dec    col0        ; back one column
  153.     mov    al,' '        ; ascii space character
  154.     call    dsw        ; direct screen write
  155.     jmp    short dis_x    ; finish
  156. ; carriage return
  157. dis_2:    mov    col0,0        ; column zero
  158.     jmp    short dis_x    ; finish
  159. ; bell
  160. dis_4:    push    si        ; save si
  161.     mov    ah,14        ; write tty
  162.     int    10h        ; bios video tty beep
  163.     pop    si        ; restore si
  164. ; exit
  165. dis_x:    mov    ah,2        ; set cursor posn
  166.     mov    dh,row0        ; row
  167.     mov    dl,col0        ; column
  168.     mov    bh,0        ; first page
  169.     int    10h        ; bios video function
  170.     pop    ax        ; restore char
  171.     ret            ; done
  172. display    endp
  173.     page
  174. ;
  175. ; internal routine
  176. ; add character to input buffer
  177. ;
  178.     assume    ds:dgroup
  179. stuff    proc    near
  180.     cmp    in_cnt,in_len    ; is the buffer full?
  181.     jae    st_2        ; exit if so
  182.     mov    bx,in_head    ; head ptr
  183.     mov    0[bx],al    ; store char in buffer
  184.     inc    bx        ; bump ptr
  185.     mov    cx,offset dgroup:inbuf    ; input buffer
  186.     add    cx,in_len    ; ptr to end of buffer
  187.     cmp    bx,cx        ; past the end?
  188.     jb    st_1        ; jump if not
  189.     mov    bx,offset dgroup:inbuf    ; wrap if so
  190. st_1:    mov    in_head,bx    ; update pointer
  191.     inc    in_cnt        ; bump count
  192. st_2:    cmp    al,cr        ; carriage return?
  193.     jne    st_x        ; jump if not
  194.     inc    cr_count    ; bump carriage return count
  195. st_x:    ret            ; done
  196. stuff    endp
  197. ;
  198. ; internal routine
  199. ; remove most recent character from input buffer
  200. ;
  201.     assume    ds:dgroup
  202. unstuff    proc    near
  203.     cmp    in_cnt,0    ; is the buffer empty?
  204.     je    un_x        ; exit if so
  205.     mov    bx,in_head    ; head ptr
  206.     mov    cx,offset dgroup:inbuf    ; input buffer
  207.     cmp    bx,cx        ; at the beginning?
  208.     ja    un_1        ; jump if not
  209.     mov    bx,offset dgroup:inbuf    ; if so,
  210.     add    bx,in_len    ; then wrap
  211. un_1:    dec    bx        ; dink ptr
  212.     mov    in_head,bx    ; update pointer
  213.     dec    in_cnt        ; dink count
  214.     cmp    byte ptr 0[bx],cr    ; was it a carriage return?
  215.     jne    un_x        ; jump if not
  216.     dec    cr_count    ; dink carriage return count
  217. un_x:    ret            ; done
  218. unstuff    endp
  219.     page
  220. ;
  221. ; buffer and display incoming character
  222. ; char in al
  223. ;
  224.     assume    ds:dgroup
  225. b_and_d    proc    near
  226. ; backspace and del
  227.     cmp    bs_local,1    ; process bs ourselves
  228.     jne    bd_2        ; jump if not
  229.     cmp    al,bs        ; backspace character?
  230.     je    bd_1        ; jump if so
  231.     cmp    al,del        ; del character?
  232.     jne    bd_2        ; jump if not
  233. bd_1:    call    unstuff        ; remove latest character
  234.     jmp    short bd_3    ; continue
  235. ; pseudo word wrap
  236. bd_2:    cmp    al,' '        ; blank?
  237.     je    bd_2a        ; jump if so
  238.     cmp    al,tab        ; tab?
  239.     jne    bd_2b        ; jump if not
  240. bd_2a:    mov    bl,wrap0    ; wrap on space column
  241.     cmp    col0,bl        ; wrap on space?
  242.     jb    bd_2b        ; jump if not
  243.     mov    al,cr        ; substitute a carriage return
  244.     mov    soft_cr,true    ; a soft one
  245. ; normal character
  246. bd_2b:    call    stuff        ; insert character in buffer
  247. ; display character and advance cursor
  248. bd_3:    cmp    ecco,-1        ; are we echoing?
  249.     jne    bd_x        ; jump if not
  250.     call    display        ; display character
  251. ; check for line wrap
  252.     mov    bl,col0        ; no. of characters so far
  253.     cmp    bl,wrapcol    ; line too long?
  254.     jb    bd_4        ; jump if not
  255.     cmp    bl,wrap0    ; line way too long?
  256.     jae    bd_3a        ; do fake cr if so
  257.     cmp    wrap0,wrapcol    ; about to overflow display line?
  258.     ja    bd_5        ; avoid this
  259. bd_3a:    mov    al,cr        ; else fake a carriage return
  260.     mov    soft_cr,true    ; a soft one
  261.     jmp    bd_2        ; put it in inbuf & display it
  262. ; treat carriage return specially
  263. bd_4:    cmp    al,cr        ; carriage return?
  264.     jne    bd_x        ; jump if not
  265. bd_5:    mov    ecco,1        ; stop echoing
  266. bd_x:    ret            ; done
  267. b_and_d    endp
  268.     page
  269. ;
  270. ; internal routine
  271. ; add character to function key buffer
  272. ;
  273.     assume    ds:dgroup
  274. bufunc    proc    near
  275.     cmp    f_cnt,f_len    ; is the buffer full?
  276.     jae    bf_x        ; exit if so
  277.     mov    bx,f_head    ; head ptr
  278.     mov    0[bx],ah    ; store key number in buffer
  279.     inc    bx        ; bump ptr
  280.     mov    cx,offset dgroup:fbuf    ; function key buffer
  281.     add    cx,f_len    ; ptr to end of buffer
  282.     cmp    bx,cx        ; past the end?
  283.     jb    bf_1        ; jump if not
  284.     mov    bx,offset dgroup:fbuf    ; wrap if so
  285. bf_1:    mov    f_head,bx    ; update pointer
  286.     inc    f_cnt        ; bump count
  287. bf_x:    ret            ; done
  288. bufunc    endp
  289.     page
  290. ;
  291. ; internal routine
  292. ; key interrupt handler
  293. ;
  294.     assume    ds